
/*!
***********************************************************************
* \file image.c
*
* \brief
*    Decode a Slice
*
* \author
*    Main contributors (see contributors.h for copyright, address and affiliation details)
*    - Inge Lille-Langoy               <inge.lille-langoy@telenor.com>
*    - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
*    - Jani Lainema                    <jani.lainema@nokia.com>
*    - Sebastian Purreiter             <sebastian.purreiter@mch.siemens.de>
*    - Byeong-Moon Jeon                <jeonbm@lge.com>
*    - Thomas Wedi                     <wedi@tnt.uni-hannover.de>
*    - Gabi Blaettermann
*    - Ye-Kui Wang                     <wyk@ieee.org>
*    - Antti Hallapuro                 <antti.hallapuro@nokia.com>
*    - Alexis Tourapis                 <alexismt@ieee.org>
*    - Jill Boyce                      <jill.boyce@thomson.net>
*    - Saurav K Bandyopadhyay          <saurav@ieee.org>
*    - Zhenyu Wu                       <Zhenyu.Wu@thomson.net
*    - Purvin Pandit                   <Purvin.Pandit@thomson.net>
*
***********************************************************************
*/

#include "contributors.h"

#include <math.h>
#include <limits.h>

#include "global.h"
#include "image.h"
#include "fmo.h"
#include "annexb.h"
#include "nalu.h"
#include "parset.h"
#include "header.h"

#include "sei.h"
#include "output.h"
#include "mb_access.h"
#include "memalloc.h"
#include "macroblock.h"

#include "loopfilter.h"

#include "biaridecod.h"
#include "context_ini.h"
#include "cabac.h"
#include "vlc.h"
#include "quant.h"

#include "errorconcealment.h"
#include "erc_api.h"

extern objectBuffer_t *erc_object_list;
extern ercVariables_t *erc_errorVar;
extern frame erc_recfr;
extern int erc_mvperMB;
extern ImageParameters *erc_img;

extern StorablePicture **listX[6];
extern ColocatedParams *Co_located;

extern StorablePicture *no_reference_picture;
int non_conforming_stream;

StorablePicture *dec_picture;
StorablePicture *dec_picture_JV[MAX_PLANE];  //!< dec_picture to be used during 4:4:4 independent mode decoding

OldSliceParams old_slice;
const int ONE_FOURTH_TAP[2][3] =
{
  {20, -5, 1},  // AVC Interpolation taps
  {20,-4, 0},   // Experimental - not valid
};
//extern const int ONE_FOURTH_TAP[2][3];

/*!
************************************************************************
* \brief
*    Initializes the parameters for a new picture
************************************************************************
*/
static void init_picture(ImageParameters *img, Slice *currSlice, struct inp_par *inp)
{
	int i;
	int nplane;

	if (dec_picture)
	{
		// this may only happen on slice loss
		exit_picture(&dec_picture);
	}
	if (img->recovery_point)
		img->recovery_frame_num = (img->frame_num + img->recovery_frame_cnt) % img->MaxFrameNum;

	if (img->idr_flag)
		img->recovery_frame_num = img->frame_num;

	if (img->recovery_point == 0 &&
		img->frame_num != img->pre_frame_num &&
		img->frame_num != (img->pre_frame_num + 1) % img->MaxFrameNum)
	{
		if (active_sps->gaps_in_frame_num_value_allowed_flag == 0)
		{
			// picture error concealment
			if(inp->conceal_mode !=0)
			{
				if((img->frame_num) < ((img->pre_frame_num + 1) % img->MaxFrameNum))
				{
					/* Conceal lost IDR frames and any frames immediately
					following the IDR. Use frame copy for these since
					lists cannot be formed correctly for motion copy*/
					img->conceal_mode = 1;
					img->IDR_concealment_flag = 1;
					conceal_lost_frames(img);
					//reset to original concealment mode for future drops
					img->conceal_mode = inp->conceal_mode;
				}
				else
				{
					//reset to original concealment mode for future drops
					img->conceal_mode = inp->conceal_mode;

					img->IDR_concealment_flag = 0;
					conceal_lost_frames(img);
				}
			}
			else
			{   /* Advanced Error Concealment would be called here to combat unintentional loss of pictures. */
				error("An unintentional loss of pictures occurs! Exit\n", 100);
			}
		}
		if(img->conceal_mode == 0)
			fill_frame_num_gap(img);
	}

	if(img->nal_reference_idc)
	{
		img->pre_frame_num = img->frame_num;
	}

	img->num_dec_mb = 0;

	//calculate POC
	decode_poc(img);

	if (img->recovery_frame_num == img->frame_num &&
		img->recovery_poc == 0x7fffffff)
		img->recovery_poc = img->framepoc;

	if(img->nal_reference_idc)
		img->last_ref_pic_poc = img->framepoc;

	//  dumppoc (img);

	if (img->structure==FRAME ||img->structure==TOP_FIELD)
	{
		gettime (&(img->start_time));             // start time
	}

	dec_picture = alloc_storable_picture ((PictureStructure) img->structure, img->width, img->height, img->width_cr, img->height_cr);
	dec_picture->top_poc=img->toppoc;
	dec_picture->bottom_poc=img->bottompoc;
	dec_picture->frame_poc=img->framepoc;
	dec_picture->qp = img->qp;
	dec_picture->slice_qp_delta = currSlice->slice_qp_delta;
	dec_picture->chroma_qp_offset[0] = active_pps->chroma_qp_index_offset;
	dec_picture->chroma_qp_offset[1] = active_pps->second_chroma_qp_index_offset;

	// reset all variables of the error concealment instance before decoding of every frame.
	// here the third parameter should, if perfectly, be equal to the number of slices per frame.
	// using little value is ok, the code will allocate more memory if the slice number is larger
	ercReset(erc_errorVar, img->PicSizeInMbs, img->PicSizeInMbs, dec_picture->size_x);
	erc_mvperMB = 0;

	switch (img->structure )
	{
	case TOP_FIELD:
		{
			dec_picture->poc=img->toppoc;
			img->number *= 2;
			break;
		}
	case BOTTOM_FIELD:
		{
			dec_picture->poc=img->bottompoc;
			img->number = img->number * 2 + 1;
			break;
		}
	case FRAME:
		{
			dec_picture->poc=img->framepoc;
			break;
		}
	default:
		error("img->structure not initialized", 235);
	}

	img->current_slice_nr=0;

	if (img->type > SI_SLICE)
	{
		set_ec_flag(SE_PTYPE);
		img->type = P_SLICE;  // concealed element
	}

	// CAVLC init
	if (active_pps->entropy_coding_mode_flag == UVLC)
	{
		memset(&img->nz_coeff[0][0][0][0], -1, img->PicSizeInMbs * 3 * 4 * 4 *sizeof(byte));
	}

	if(active_pps->constrained_intra_pred_flag)
	{
		for (i=0; i<(int)img->PicSizeInMbs; i++)
		{
			img->intra_block[i] = 1;
		}
	}

	// Set the slice_nr member of each MB to -1, to ensure correct when packet loss occurs
	// TO set Macroblock Map (mark all MBs as 'have to be concealed')
	if( IS_INDEPENDENT(img) )
	{
		for( nplane=0; nplane<MAX_PLANE; nplane++ )
		{      
			for(i=0; i<(int)img->PicSizeInMbs; i++)
			{
				img->mb_data_JV[nplane][i].slice_nr = -1; 
				img->mb_data_JV[nplane][i].ei_flag = 1;
				img->mb_data_JV[nplane][i].dpl_flag = 0;
			}
		}
	}
	else
	{
		for(i=0; i<(int)img->PicSizeInMbs; i++)
		{
			img->mb_data[i].slice_nr = -1; 
			img->mb_data[i].ei_flag = 1;
			img->mb_data[i].dpl_flag = 0;
		}
	}

	img->mb_y = img->mb_x = 0;
	img->block_y_aff = img->block_y = img->pix_y = img->pix_c_y = 0; // define vertical positions
	img->block_x = img->pix_x = img->pix_c_x = 0; // define horizontal positions

	dec_picture->slice_type = img->type;
	dec_picture->used_for_reference = (img->nal_reference_idc != 0);
	dec_picture->idr_flag = img->idr_flag;
	dec_picture->no_output_of_prior_pics_flag = img->no_output_of_prior_pics_flag;
	dec_picture->long_term_reference_flag = img->long_term_reference_flag;
	dec_picture->adaptive_ref_pic_buffering_flag = img->adaptive_ref_pic_buffering_flag;

	dec_picture->dec_ref_pic_marking_buffer = img->dec_ref_pic_marking_buffer;
	img->dec_ref_pic_marking_buffer = NULL;

	dec_picture->MbaffFrameFlag = img->MbaffFrameFlag;
	dec_picture->PicWidthInMbs = img->PicWidthInMbs;

	get_mb_block_pos = dec_picture->MbaffFrameFlag ? get_mb_block_pos_mbaff : get_mb_block_pos_normal;
	getNeighbour = dec_picture->MbaffFrameFlag ? getAffNeighbour : getNonAffNeighbour;

	dec_picture->pic_num = img->frame_num;
	dec_picture->frame_num = img->frame_num;

	dec_picture->recovery_frame = (img->frame_num == img->recovery_frame_num);

	dec_picture->coded_frame = (img->structure==FRAME);

	dec_picture->chroma_format_idc = active_sps->chroma_format_idc;

	dec_picture->frame_mbs_only_flag = active_sps->frame_mbs_only_flag;
	dec_picture->frame_cropping_flag = active_sps->frame_cropping_flag;

	if (dec_picture->frame_cropping_flag)
	{
		dec_picture->frame_cropping_rect_left_offset   = active_sps->frame_cropping_rect_left_offset;
		dec_picture->frame_cropping_rect_right_offset  = active_sps->frame_cropping_rect_right_offset;
		dec_picture->frame_cropping_rect_top_offset    = active_sps->frame_cropping_rect_top_offset;
		dec_picture->frame_cropping_rect_bottom_offset = active_sps->frame_cropping_rect_bottom_offset;
	}

#if (ENABLE_OUTPUT_TONEMAPPING)
	// store the necessary tone mapping sei into StorablePicture structure
	dec_picture->seiHasTone_mapping = 0;
	if (seiToneMapping.seiHasTone_mapping)
	{
		dec_picture->seiHasTone_mapping    = 1;
		dec_picture->tone_mapping_model_id = seiToneMapping.model_id;
		dec_picture->tonemapped_bit_depth  = seiToneMapping.sei_bit_depth;
		dec_picture->tone_mapping_lut      = malloc(sizeof(int)*(1<<seiToneMapping.coded_data_bit_depth));
		if (NULL == dec_picture->tone_mapping_lut)
		{
			no_mem_exit("init_picture: tone_mapping_lut");
		}
		memcpy(dec_picture->tone_mapping_lut, seiToneMapping.lut, sizeof(imgpel)*(1<<seiToneMapping.coded_data_bit_depth));
		update_tone_mapping_sei();
	}
#endif

	if( IS_INDEPENDENT(img) )
	{
		dec_picture_JV[0] = dec_picture;
		dec_picture_JV[1] = alloc_storable_picture ((PictureStructure) img->structure, img->width, img->height, img->width_cr, img->height_cr);
		copy_dec_picture_JV( dec_picture_JV[1], dec_picture_JV[0] );
		dec_picture_JV[2] = alloc_storable_picture ((PictureStructure) img->structure, img->width, img->height, img->width_cr, img->height_cr);
		copy_dec_picture_JV( dec_picture_JV[2], dec_picture_JV[0] );
	}
}

void MbAffPostProc(void)
{
	imgpel temp[32][16];

	imgpel ** imgY  = dec_picture->imgY;
	imgpel ***imgUV = dec_picture->imgUV;

	int i, y, x0, y0, uv;
	for (i=0; i<(int)dec_picture->PicSizeInMbs; i+=2)
	{
		if (dec_picture->motion.mb_field[i])
		{
			get_mb_pos(i, img->mb_size[IS_LUMA], &x0, &y0);
			for (y=0; y<(2*MB_BLOCK_SIZE);y++)
				memcpy(temp[y], &imgY[y0+y][x0], MB_BLOCK_SIZE * sizeof(imgpel));

			for (y=0; y<MB_BLOCK_SIZE;y++)
			{
				memcpy(&imgY[y0+(2*y  )][x0], temp[y              ], MB_BLOCK_SIZE * sizeof(imgpel));
				memcpy(&imgY[y0+(2*y+1)][x0], temp[y+MB_BLOCK_SIZE], MB_BLOCK_SIZE * sizeof(imgpel));
			}


			if (dec_picture->chroma_format_idc != YUV400)
			{
				x0 = x0 / (16/img->mb_cr_size_x);
				y0 = y0 / (16/img->mb_cr_size_y);

				for (uv=0; uv<2; uv++)
				{
					for (y=0; y<(2*img->mb_cr_size_y);y++)
						memcpy(temp[y], &imgUV[uv][y0+y][x0], img->mb_cr_size_x * sizeof(imgpel));

					for (y=0; y<img->mb_cr_size_y;y++)
					{
						memcpy(&imgUV[uv][y0+(2*y  )][x0], temp[y                  ], img->mb_cr_size_x * sizeof(imgpel));
						memcpy(&imgUV[uv][y0+(2*y+1)][x0], temp[y+img->mb_cr_size_y], img->mb_cr_size_x * sizeof(imgpel));
					}
				}
			}
		}
	}
}

static void fill_wp_params(ImageParameters *img)
{
	int i, j, k;
	int comp;
	int log_weight_denom;
	int tb, td;
	int bframe = (img->type==B_SLICE);
	int tx,DistScaleFactor;

	int max_l0_ref = img->num_ref_idx_l0_active;
	int max_l1_ref = img->num_ref_idx_l1_active;

	if (active_pps->weighted_bipred_idc == 2 && bframe)
	{
		img->luma_log2_weight_denom = 5;
		img->chroma_log2_weight_denom = 5;
		img->wp_round_luma = 16;
		img->wp_round_chroma = 16;

		for (i=0; i<MAX_REFERENCE_PICTURES; i++)
		{
			for (comp=0; comp<3; comp++)
			{
				log_weight_denom = (comp == 0) ? img->luma_log2_weight_denom : img->chroma_log2_weight_denom;
				img->wp_weight[0][i][comp] = 1<<log_weight_denom;
				img->wp_weight[1][i][comp] = 1<<log_weight_denom;
				img->wp_offset[0][i][comp] = 0;
				img->wp_offset[1][i][comp] = 0;
			}
		}
	}

	if (bframe)
	{
		for (i=0; i<max_l0_ref; i++)
		{
			for (j=0; j<max_l1_ref; j++)
			{
				for (comp = 0; comp<3; comp++)
				{
					log_weight_denom = (comp == 0) ? img->luma_log2_weight_denom : img->chroma_log2_weight_denom;
					if (active_pps->weighted_bipred_idc == 1)
					{
						img->wbp_weight[0][i][j][comp] =  img->wp_weight[0][i][comp];
						img->wbp_weight[1][i][j][comp] =  img->wp_weight[1][j][comp];
					}
					else if (active_pps->weighted_bipred_idc == 2)
					{
						td = iClip3(-128,127,listX[LIST_1][j]->poc - listX[LIST_0][i]->poc);
						if (td == 0 || listX[LIST_1][j]->is_long_term || listX[LIST_0][i]->is_long_term)
						{
							img->wbp_weight[0][i][j][comp] = 32;
							img->wbp_weight[1][i][j][comp] = 32;
						}
						else
						{
							tb = iClip3(-128,127,img->ThisPOC - listX[LIST_0][i]->poc);

							tx = (16384 + iabs(td/2))/td;
							DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);

							img->wbp_weight[1][i][j][comp] = DistScaleFactor >> 2;
							img->wbp_weight[0][i][j][comp] = 64 - img->wbp_weight[1][i][j][comp];
							if (img->wbp_weight[1][i][j][comp] < -64 || img->wbp_weight[1][i][j][comp] > 128)
							{
								img->wbp_weight[0][i][j][comp] = 32;
								img->wbp_weight[1][i][j][comp] = 32;
								img->wp_offset[0][i][comp] = 0;
								img->wp_offset[1][j][comp] = 0;
							}
						}
					}
				}
			}
		}
	}

	if (bframe && img->MbaffFrameFlag)
	{
		for (i=0; i<2*max_l0_ref; i++)
		{
			for (j=0; j<2*max_l1_ref; j++)
			{
				for (comp = 0; comp<3; comp++)
				{
					for (k=2; k<6; k+=2)
					{
						img->wp_offset[k+0][i][comp] = img->wp_offset[0][i>>1][comp];
						img->wp_offset[k+1][j][comp] = img->wp_offset[1][j>>1][comp];

						log_weight_denom = (comp == 0) ? img->luma_log2_weight_denom : img->chroma_log2_weight_denom;
						if (active_pps->weighted_bipred_idc == 1)
						{
							img->wbp_weight[k+0][i][j][comp] =  img->wp_weight[0][i>>1][comp];
							img->wbp_weight[k+1][i][j][comp] =  img->wp_weight[1][j>>1][comp];
						}
						else if (active_pps->weighted_bipred_idc == 2)
						{
							td = iClip3(-128,127,listX[k+LIST_1][j]->poc - listX[k+LIST_0][i]->poc);
							if (td == 0 || listX[k+LIST_1][j]->is_long_term || listX[k+LIST_0][i]->is_long_term)
							{
								img->wbp_weight[k+0][i][j][comp] =   32;
								img->wbp_weight[k+1][i][j][comp] =   32;
							}
							else
							{
								tb = iClip3(-128,127,((k==2)?img->toppoc:img->bottompoc) - listX[k+LIST_0][i]->poc);

								tx = (16384 + iabs(td/2))/td;
								DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);

								img->wbp_weight[k+1][i][j][comp] = DistScaleFactor >> 2;
								img->wbp_weight[k+0][i][j][comp] = 64 - img->wbp_weight[k+1][i][j][comp];
								if (img->wbp_weight[k+1][i][j][comp] < -64 || img->wbp_weight[k+1][i][j][comp] > 128)
								{
									img->wbp_weight[k+1][i][j][comp] = 32;
									img->wbp_weight[k+0][i][j][comp] = 32;
									img->wp_offset[k+0][i][comp] = 0;
									img->wp_offset[k+1][j][comp] = 0;
								}
							}
						}
					}
				}
			}
		}
	}
}

static void decode_slice(ImageParameters *img, Slice *currSlice, struct inp_par *inp, int current_header)
{
	if (active_pps->entropy_coding_mode_flag)
	{
		init_contexts (img);
		cabac_new_slice();
	}

	if ( (active_pps->weighted_bipred_idc > 0  && (img->type == B_SLICE)) || (active_pps->weighted_pred_flag && img->type !=I_SLICE))
		fill_wp_params(img);

	//printf("frame picture %d %d %d\n",img->structure,img->ThisPOC,img->direct_spatial_mv_pred_flag);

	// decode main slice information
	if ((current_header == SOP || current_header == SOS) && currSlice->ei_flag == 0)
		decode_one_slice(img, currSlice, inp);

	// setMB-Nr in case this slice was lost
	// if(currSlice->ei_flag)
	//   img->current_mb_nr = currSlice->last_mb_nr + 1;
}


/*!
************************************************************************
* \brief
*    Error tracking: if current frame is lost or any reference frame of
*                    current frame is lost, current frame is incorrect.
************************************************************************
*/
static void Error_tracking(void)
{
	int i;

	if(img->redundant_pic_cnt == 0)
	{
		Is_primary_correct = Is_redundant_correct = 1;
	}

	if(img->redundant_pic_cnt == 0 && img->type != I_SLICE)
	{
		for(i=0;i<img->num_ref_idx_l0_active;i++)
		{
			if(ref_flag[i] == 0)  // any reference of primary slice is incorrect
			{
				Is_primary_correct = 0; // primary slice is incorrect
			}
		}
	}
	else if(img->redundant_pic_cnt != 0 && img->type != I_SLICE)
	{
		if(ref_flag[redundant_slice_ref_idx] == 0)  // reference of redundant slice is incorrect
		{
			Is_redundant_correct = 0;  // redundant slice is incorrect
		}
	}
}

/*!
***********************************************************************
* \brief
*    decodes one I- or P-frame
*
***********************************************************************
*/

int decode_one_frame(ImageParameters *img, struct inp_par *inp, struct snr_par *snr)
{
	int current_header;
	Slice *currSlice = img->currentSlice;
	int i;

	img->current_slice_nr = 0;
	img->current_mb_nr = -4711;     // initialized to an impossible value for debugging -- correct value is taken from slice header
	currSlice->next_header = -8888; // initialized to an impossible value for debugging -- correct value is taken from slice header
	img->num_dec_mb = 0;
	img->newframe = 1;
	get_mem4Dpel (&cImgSub_cmb, 4, 4, 22, 22);
	get_mem2Dint (&imgY_sub_cmb, 22, 22);

	while ((currSlice->next_header != EOS && currSlice->next_header != SOP))
	{
		current_header = read_new_slice(img->currentSlice);

		// error tracking of primary and redundant slices.
		Error_tracking();

		// If primary and redundant are received and primary is correct, discard the redundant
		// else, primary slice will be replaced with redundant slice.
		if(img->frame_num == previous_frame_num && img->redundant_pic_cnt !=0
			&& Is_primary_correct !=0 && current_header != EOS)
		{
			continue;
		}

		// update reference flags and set current ref_flag
		if(!(img->redundant_pic_cnt != 0 && previous_frame_num == img->frame_num))
		{
			for(i=16;i>0;i--)
			{
				ref_flag[i] = ref_flag[i-1];
			}
		}
		ref_flag[0] = img->redundant_pic_cnt==0 ? Is_primary_correct : Is_redundant_correct;
		previous_frame_num = img->frame_num;

		if (current_header == EOS)
		{
			exit_picture(&dec_picture);
			return EOS;
		}

		decode_slice(img, currSlice, inp, current_header);

		img->newframe = 0;
		img->current_slice_nr++;
	}

	exit_picture(&dec_picture);

	return (SOP);
}


/*!
************************************************************************
* \brief
*    Convert file read buffer to source picture structure
* \param imgX
*    Pointer to image plane
* \param buf
*    Buffer for file output
* \param size_x
*    horizontal image size in pixel
* \param size_y
*    vertical image size in pixel
* \param symbol_size_in_bytes
*    number of bytes used per pel
************************************************************************
*/
void buf2img (imgpel** imgX, unsigned char* buf, int size_x, int size_y, int symbol_size_in_bytes)
{
	int i,j;

	unsigned short tmp16, ui16;
	unsigned long  tmp32, ui32;

	if (symbol_size_in_bytes> sizeof(imgpel))
	{
		error ("Source picture has higher bit depth than imgpel data type. \nPlease recompile with larger data type for imgpel.", 500);
	}

	if (( sizeof(char) == sizeof (imgpel)) && ( sizeof(char) == symbol_size_in_bytes))
	{
		// imgpel == pixel_in_file == 1 byte -> simple copy
		memcpy(&imgX[0][0], buf, size_x * size_y);
		//for(j=0;j<size_y;j++)
		//memcpy(&imgX[j][0], buf+j*size_x, size_x);
	}
	else
	{
		// sizeof (imgpel) > sizeof(char)
		if (testEndian())
		{
			// big endian
			switch (symbol_size_in_bytes)
			{
			case 1:
				{
					for(j=0;j<size_y;j++)
						for(i=0;i<size_x;i++)
						{
							imgX[j][i]= buf[i+j*size_x];
						}
						break;
				}
			case 2:
				{
					for(j=0;j<size_y;j++)
						for(i=0;i<size_x;i++)
						{
							memcpy(&tmp16, buf+((i+j*size_x)*2), 2);
							ui16  = (unsigned short) ((tmp16 >> 8) | ((tmp16&0xFF)<<8));
							imgX[j][i] = (imgpel) ui16;
						}
						break;
				}
			case 4:
				{
					for(j=0;j<size_y;j++)
						for(i=0;i<size_x;i++)
						{
							memcpy(&tmp32, buf+((i+j*size_x)*4), 4);
							ui32  = ((tmp32&0xFF00)<<8) | ((tmp32&0xFF)<<24) | ((tmp32&0xFF0000)>>8) | ((tmp32&0xFF000000)>>24);
							imgX[j][i] = (imgpel) ui32;
						}
				}
			default:
				{
					error ("reading only from formats of 8, 16 or 32 bit allowed on big endian architecture", 500);
					break;
				}
			}

		}
		else
		{
			// little endian
			if (symbol_size_in_bytes == 1)
			{
				for (j=0; j < size_y; j++)
				{
					for (i=0; i < size_x; i++)
					{
						imgX[j][i]=*(buf++);
					}
				}
			}
			else
			{
				for (j=0; j < size_y; j++)
				{
					int jpos = j*size_x;
					for (i=0; i < size_x; i++)
					{
						imgX[j][i]=0;
						memcpy(&(imgX[j][i]), buf +((i+jpos)*symbol_size_in_bytes), symbol_size_in_bytes);
					}
				}
			}

		}
	}
}


/*!
************************************************************************
* \brief
*    Calculate the value of frame_no
************************************************************************
*/
void calculate_frame_no(StorablePicture *p)
{
	// calculate frame number
	int  psnrPOC = active_sps->mb_adaptive_frame_field_flag ? p->poc /(params->poc_scale) : p->poc/(params->poc_scale);

	if (psnrPOC==0)// && img->psnr_number)
		img->idr_psnr_number = img->number*img->ref_poc_gap/(params->poc_scale);

	img->psnr_number=imax(img->psnr_number,img->idr_psnr_number+psnrPOC);

	frame_no = img->idr_psnr_number + psnrPOC;
}


/*!
************************************************************************
* \brief
*    Find PSNR for all three components.Compare decoded frame with
*    the original sequence. Read inp->jumpd frames to reflect frame skipping.
************************************************************************
*/
void find_snr(struct snr_par  *snr,   //!< pointer to snr parameters
			  StorablePicture *p,     //!< picture to be compared
			  int *p_ref)              //!< open reference YUV file
{
	static const int SubWidthC  [4]= { 1, 2, 2, 1};
	static const int SubHeightC [4]= { 1, 2, 1, 1};
	int crop_left, crop_right, crop_top, crop_bottom;

	int i,j, k;
	int ret;
	int64 diff_comp[3] = {0};
	int64  status;
	int symbol_size_in_bytes = img->pic_unit_bitsize_on_disk/8;
	int comp_size_x[3], comp_size_y[3];
	int64 framesize_in_bytes;

	unsigned int max_pix_value_sqd[3] = {iabs2(img->max_imgpel_value_comp[0]),  iabs2(img->max_imgpel_value_comp[1]), iabs2(img->max_imgpel_value_comp[2])};

	Boolean rgb_output = (Boolean) (active_sps->vui_seq_parameters.matrix_coefficients==0);
	unsigned char *buf;
	imgpel **cur_ref[3]  = {imgY_ref, p->chroma_format_idc != YUV400 ? imgUV_ref[0] : NULL, p->chroma_format_idc != YUV400 ? imgUV_ref[1] : NULL};
	imgpel **cur_comp[3] = {p->imgY,  p->chroma_format_idc != YUV400 ? p->imgUV[0]  : NULL , p->chroma_format_idc!= YUV400 ? p->imgUV[1]  : NULL}; 
	// picture error concealment
	char yuv_types[4][6]= {"4:0:0","4:2:0","4:2:2","4:4:4"};

	// cropping for luma
	if (p->frame_cropping_flag)
	{
		crop_left   = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_left_offset;
		crop_right  = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_right_offset;
		crop_top    = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) *  p->frame_cropping_rect_top_offset;
		crop_bottom = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) *  p->frame_cropping_rect_bottom_offset;
	}
	else
	{
		crop_left = crop_right = crop_top = crop_bottom = 0;
	}

	comp_size_x[0] = p->size_x - crop_left - crop_right;
	comp_size_y[0] = p->size_y - crop_top - crop_bottom;

	// cropping for chroma
	if (p->frame_cropping_flag)
	{
		crop_left   = p->frame_cropping_rect_left_offset;
		crop_right  = p->frame_cropping_rect_right_offset;
		crop_top    = ( 2 - p->frame_mbs_only_flag ) *  p->frame_cropping_rect_top_offset;
		crop_bottom = ( 2 - p->frame_mbs_only_flag ) *   p->frame_cropping_rect_bottom_offset;
	}
	else
	{
		crop_left = crop_right = crop_top = crop_bottom = 0;
	}

	if ((p->chroma_format_idc==YUV400) && params->write_uv)
	{
		comp_size_x[1] = comp_size_x[2] = (p->size_x >> 1);
		comp_size_y[1] = comp_size_y[2] = (p->size_y >> 1);
	}
	else
	{
		// These could be computed once and attached to the StorablePicture structure
		comp_size_x[1] = comp_size_x[2] = (p->size_x_cr - crop_left - crop_right); 
		comp_size_y[1] = comp_size_y[2] = (p->size_y_cr - crop_top  - crop_bottom);
	}

	framesize_in_bytes = (((int64) comp_size_x[0] * comp_size_y[0]) + ((int64) comp_size_x[1] * comp_size_y[1] ) * 2) * symbol_size_in_bytes;

	// KS: this buffer should actually be allocated only once, but this is still much faster than the previous version
	buf = malloc ( comp_size_x[0] * comp_size_y[0] * symbol_size_in_bytes );

	if (NULL == buf)
	{
		no_mem_exit("find_snr: buf");
	}

	status = lseek (*p_ref, framesize_in_bytes * frame_no, SEEK_SET);
	if (status == -1)
	{
		fprintf(stderr, "Error in seeking frame number: %d\n", frame_no);
		free (buf);
		return;
	}

	if(rgb_output)
		lseek (*p_ref, framesize_in_bytes/3, SEEK_CUR);

	for (k = 0; k < ((p->chroma_format_idc != YUV400) ? 3 : 1); k++)
	{

		if(rgb_output && k == 2)
			lseek (*p_ref, -framesize_in_bytes, SEEK_CUR);

		ret = read(*p_ref, buf, comp_size_x[k] * comp_size_y[k] * symbol_size_in_bytes);
		if (ret != comp_size_x[k] * comp_size_y[k] * symbol_size_in_bytes)
		{
			printf ("Warning: could not read from reconstructed file\n");
			memset (buf, 0, comp_size_x[k] * comp_size_y[k] * symbol_size_in_bytes);
			close(*p_ref);
			*p_ref = -1;
			break;
		}
		buf2img(cur_ref[k], buf, comp_size_x[k], comp_size_y[k], symbol_size_in_bytes);

		for (j=0; j < comp_size_y[k]; ++j)
		{
			for (i=0; i < comp_size_x[k]; ++i)
			{
				diff_comp[k] += iabs2(cur_comp[k][j][i] - cur_ref[k][j][i]);
			}
		}

		// Collecting SNR statistics
		snr->snr[k] = psnr( max_pix_value_sqd[k], comp_size_x[k] * comp_size_y[k], (float) diff_comp[k]);   

		if (img->number == 0) // first
		{
			snr->snra[k] = snr->snr[k];                                                        // keep luma snr for first frame
		}
		else
		{
			snr->snra[k] = (float)(snr->snra[k]*(snr->frame_ctr)+snr->snr[k])/(snr->frame_ctr + 1); // average snr chroma for all frames
		}
	}

	if(rgb_output)
		lseek (*p_ref, framesize_in_bytes*2/3, SEEK_CUR);

	free (buf);

	// picture error concealment
	if(p->concealed_pic)
	{
		fprintf(stdout,"%04d(P)  %8d %5d %5d %7.4f %7.4f %7.4f  %s %5d\n",
			frame_no, p->frame_poc, p->pic_num, p->qp,
			snr->snr[0], snr->snr[1], snr->snr[2], yuv_types[p->chroma_format_idc], 0);
	}
}


void reorder_lists(int currSliceType, Slice * currSlice)
{
	if ((currSliceType != I_SLICE)&&(currSliceType != SI_SLICE))
	{
		if (currSlice->ref_pic_list_reordering_flag_l0)
		{
			reorder_ref_pic_list(listX[0], &listXsize[0],
				img->num_ref_idx_l0_active - 1,
				currSlice->reordering_of_pic_nums_idc_l0,
				currSlice->abs_diff_pic_num_minus1_l0,
				currSlice->long_term_pic_idx_l0);
		}
		if (no_reference_picture == listX[0][img->num_ref_idx_l0_active-1])
		{
			if (non_conforming_stream)
				printf("RefPicList0[ num_ref_idx_l0_active_minus1 ] is equal to 'no reference picture'\n");
			else
				error("RefPicList0[ num_ref_idx_l0_active_minus1 ] is equal to 'no reference picture', invalid bitstream",500);
		}
		// that's a definition
		listXsize[0] = img->num_ref_idx_l0_active;
	}
	if (currSliceType == B_SLICE)
	{
		if (currSlice->ref_pic_list_reordering_flag_l1)
		{
			reorder_ref_pic_list(listX[1], &listXsize[1],
				img->num_ref_idx_l1_active - 1,
				currSlice->reordering_of_pic_nums_idc_l1,
				currSlice->abs_diff_pic_num_minus1_l1,
				currSlice->long_term_pic_idx_l1);
		}
		if (no_reference_picture == listX[1][img->num_ref_idx_l1_active-1])
		{
			if (non_conforming_stream)
				printf("RefPicList1[ num_ref_idx_l1_active_minus1 ] is equal to 'no reference picture'\n");
			else
				error("RefPicList1[ num_ref_idx_l1_active_minus1 ] is equal to 'no reference picture', invalid bitstream",500);
		}
		// that's a definition
		listXsize[1] = img->num_ref_idx_l1_active;
	}

	free_ref_pic_list_reordering_buffer(currSlice);
}


/*!
************************************************************************
* \brief
*    initialize ref_pic_num array
************************************************************************
*/
void set_ref_pic_num(void)
{
	int i,j;

	int slice_id=img->current_slice_nr;

	for (i=0;i<listXsize[LIST_0];i++)
	{
		dec_picture->ref_pic_num        [slice_id][LIST_0][i] = listX[LIST_0][i]->poc * 2 + ((listX[LIST_0][i]->structure==BOTTOM_FIELD)?1:0) ;
		dec_picture->frm_ref_pic_num    [slice_id][LIST_0][i] = listX[LIST_0][i]->frame_poc * 2;
		dec_picture->top_ref_pic_num    [slice_id][LIST_0][i] = listX[LIST_0][i]->top_poc * 2;
		dec_picture->bottom_ref_pic_num [slice_id][LIST_0][i] = listX[LIST_0][i]->bottom_poc * 2 + 1;
		//printf("POCS %d %d %d %d ",listX[LIST_0][i]->frame_poc,listX[LIST_0][i]->bottom_poc,listX[LIST_0][i]->top_poc,listX[LIST_0][i]->poc);
		//printf("refid %d %d %d %d\n",(int) dec_picture->frm_ref_pic_num[LIST_0][i],(int) dec_picture->top_ref_pic_num[LIST_0][i],(int) dec_picture->bottom_ref_pic_num[LIST_0][i],(int) dec_picture->ref_pic_num[LIST_0][i]);
	}

	for (i=0;i<listXsize[LIST_1];i++)
	{
		dec_picture->ref_pic_num        [slice_id][LIST_1][i] = listX[LIST_1][i]->poc  *2 + ((listX[LIST_1][i]->structure==BOTTOM_FIELD)?1:0);
		dec_picture->frm_ref_pic_num    [slice_id][LIST_1][i] = listX[LIST_1][i]->frame_poc * 2;
		dec_picture->top_ref_pic_num    [slice_id][LIST_1][i] = listX[LIST_1][i]->top_poc * 2;
		dec_picture->bottom_ref_pic_num [slice_id][LIST_1][i] = listX[LIST_1][i]->bottom_poc * 2 + 1;
	}

	if (!active_sps->frame_mbs_only_flag)
	{
		if (img->structure==FRAME)
		{
			for (j=2;j<6;j++)
			{
				for (i=0;i<listXsize[j];i++)
				{
					dec_picture->ref_pic_num        [slice_id][j][i] = listX[j][i]->poc * 2 + ((listX[j][i]->structure==BOTTOM_FIELD)?1:0);
					dec_picture->frm_ref_pic_num    [slice_id][j][i] = listX[j][i]->frame_poc * 2 ;
					dec_picture->top_ref_pic_num    [slice_id][j][i] = listX[j][i]->top_poc * 2 ;
					dec_picture->bottom_ref_pic_num [slice_id][j][i] = listX[j][i]->bottom_poc * 2 + 1;
				}
			}
		}
	}
}


/*!
************************************************************************
* \brief
*    Reads new slice from bit_stream
************************************************************************
*/
int read_new_slice(Slice *currSlice)
{
	NALU_t *nalu = AllocNALU(MAX_CODED_FRAME_SIZE);
	int current_header = 0;
	int BitsUsedByHeader;
	Bitstream *currStream;

	int slice_id_a, slice_id_b, slice_id_c;
	int redundant_pic_cnt_b, redundant_pic_cnt_c;

	while (1)
	{
		if (0 == read_next_nalu(nalu))
			return EOS;

process_nalu:

		switch (nalu->nal_unit_type)
		{
		case NALU_TYPE_SLICE:
		case NALU_TYPE_IDR:

			if (img->recovery_point || nalu->nal_unit_type == NALU_TYPE_IDR)
			{
				if (img->recovery_point_found == 0)
				{
					if (nalu->nal_unit_type != NALU_TYPE_IDR)
					{
						printf("Warning: Decoding does not start with an IDR picture.\n");
						non_conforming_stream = 1;
					}
					else
						non_conforming_stream = 0;
				}
				img->recovery_point_found = 1;
			}

			if (img->recovery_point_found == 0)
				break;

			img->idr_flag = (nalu->nal_unit_type == NALU_TYPE_IDR);
			img->nal_reference_idc = nalu->nal_reference_idc;
			currSlice->dp_mode = PAR_DP_1;
			currSlice->max_part_nr = 1;
			currSlice->ei_flag = 0;
			currStream = currSlice->partArr[0].bitstream;
			currStream->ei_flag = 0;
			currStream->frame_bitoffset = currStream->read_len = 0;
			memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
			currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

			// Some syntax of the Slice Header depends on the parameter set, which depends on
			// the parameter set ID of the SLice header.  Hence, read the pic_parameter_set_id
			// of the slice header first, then setup the active parameter sets, and then read
			// the rest of the slice header
			BitsUsedByHeader = FirstPartOfSliceHeader(currSlice);
			UseParameterSet (currSlice->pic_parameter_set_id);
			BitsUsedByHeader+= RestOfSliceHeader (currSlice);

			FmoInit (active_pps, active_sps);

			AssignQuantParam (active_pps, active_sps);

			// if primary slice is replaced with redundant slice, set the correct image type
			if(img->redundant_pic_cnt && Is_primary_correct==0 && Is_redundant_correct)
			{
				dec_picture->slice_type=img->type;
			}

			if(is_new_picture(dec_picture, currSlice, &old_slice))
			{
				init_picture(img, currSlice, params);

				current_header = SOP;
				//check zero_byte if it is also the first NAL unit in the access unit
				CheckZeroByteVCL(nalu);
			}
			else
				current_header = SOS;

			init_lists(img->type, img->currentSlice->structure);
			reorder_lists (img->type, img->currentSlice);

			if (img->structure==FRAME)
			{
				init_mbaff_lists();
			}

			// From here on, active_sps, active_pps and the slice header are valid
			if (img->MbaffFrameFlag)
				img->current_mb_nr = currSlice->start_mb_nr << 1;
			else
				img->current_mb_nr = currSlice->start_mb_nr;

			if (active_pps->entropy_coding_mode_flag)
			{
				int ByteStartPosition = currStream->frame_bitoffset/8;
				if (currStream->frame_bitoffset%8 != 0)
				{
					ByteStartPosition++;
				}
				arideco_start_decoding (&currSlice->partArr[0].de_cabac, currStream->streamBuffer, ByteStartPosition, &currStream->read_len);
			}
			// printf ("read_new_slice: returning %s\n", current_header == SOP?"SOP":"SOS");
			FreeNALU(nalu);
			img->recovery_point = 0;
			return current_header;
			break;
		case NALU_TYPE_DPA:
			// read DP_A
			currSlice->dpB_NotPresent =1; 
			currSlice->dpC_NotPresent =1; 

			img->idr_flag          = FALSE;
			img->nal_reference_idc = nalu->nal_reference_idc;
			currSlice->dp_mode     = PAR_DP_3;
			currSlice->max_part_nr = 3;
			currSlice->ei_flag     = 0;
			currStream             = currSlice->partArr[0].bitstream;
			currStream->ei_flag    = 0;
			currStream->frame_bitoffset = currStream->read_len = 0;
			memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
			currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

			BitsUsedByHeader     = FirstPartOfSliceHeader(currSlice);
			UseParameterSet (currSlice->pic_parameter_set_id);
			BitsUsedByHeader    += RestOfSliceHeader (currSlice);

			FmoInit (active_pps, active_sps);

			if(is_new_picture(dec_picture, currSlice, &old_slice))
			{
				init_picture(img, currSlice, params);
				current_header = SOP;
				CheckZeroByteVCL(nalu);
			}
			else
				current_header = SOS;

			init_lists(img->type, img->currentSlice->structure);
			reorder_lists (img->type, img->currentSlice);

			if (img->structure==FRAME)
			{
				init_mbaff_lists();
			}

			// From here on, active_sps, active_pps and the slice header are valid
			if (img->MbaffFrameFlag)
				img->current_mb_nr = currSlice->start_mb_nr << 1;
			else
				img->current_mb_nr = currSlice->start_mb_nr;

			// Now I need to read the slice ID, which depends on the value of
			// redundant_pic_cnt_present_flag

			slice_id_a  = ue_v("NALU: DP_A slice_id", currStream);

			if (active_pps->entropy_coding_mode_flag)
				error ("received data partition with CABAC, this is not allowed", 500);

			// continue with reading next DP
			if (0 == read_next_nalu(nalu))
				return current_header;

			if ( NALU_TYPE_DPB == nalu->nal_unit_type)
			{
				// we got a DPB
				currStream             = currSlice->partArr[1].bitstream;
				currStream->ei_flag    = 0;
				currStream->frame_bitoffset = currStream->read_len = 0;

				memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
				currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

				slice_id_b  = ue_v("NALU: DP_B slice_id", currStream);

				currSlice->dpB_NotPresent = 0; 

				if ((slice_id_b != slice_id_a) || (nalu->lost_packets))
				{
					printf ("Waning: got a data partition B which does not match DP_A (DP loss!)\n");
					currSlice->dpB_NotPresent =1; 
					currSlice->dpC_NotPresent =1; 
				}
				else
				{
					if (active_pps->redundant_pic_cnt_present_flag)
						redundant_pic_cnt_b = ue_v("NALU: DP_B redudant_pic_cnt", currStream);
					else
						redundant_pic_cnt_b = 0;

					// we're finished with DP_B, so let's continue with next DP
					if (0 == read_next_nalu(nalu))
						return current_header;
				}
			}
			else
			{
				currSlice->dpB_NotPresent =1; 
			}

			// check if we got DP_C
			if ( NALU_TYPE_DPC == nalu->nal_unit_type)
			{
				currStream             = currSlice->partArr[2].bitstream;
				currStream->ei_flag    = 0;
				currStream->frame_bitoffset = currStream->read_len = 0;

				memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
				currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

				currSlice->dpC_NotPresent = 0;

				slice_id_c  = ue_v("NALU: DP_C slice_id", currStream);
				if ((slice_id_c != slice_id_a)|| (nalu->lost_packets))
				{
					printf ("Warning: got a data partition C which does not match DP_A(DP loss!)\n");
					//currSlice->dpB_NotPresent =1;
					currSlice->dpC_NotPresent =1;
				}

				if (active_pps->redundant_pic_cnt_present_flag)
					redundant_pic_cnt_c = ue_v("NALU:SLICE_C redudand_pic_cnt", currStream);
				else
					redundant_pic_cnt_c = 0;
			}
			else
			{
				currSlice->dpC_NotPresent =1;
			}

			// check if we read anything else than the expected partitions
			if ((nalu->nal_unit_type != NALU_TYPE_DPB) && (nalu->nal_unit_type != NALU_TYPE_DPC))
			{
				// we have a NALI that we can't process here, so restart processing
				goto process_nalu;
				// yes, "goto" should not be used, but it's really the best way here before we restructure the decoding loop
				// (which should be taken care of anyway)
			}

			FreeNALU(nalu);
			return current_header;

			break;
		case NALU_TYPE_DPB:
			printf ("found data partition B without matching DP A, discarding\n");
			break;
		case NALU_TYPE_DPC:
			printf ("found data partition C without matching DP A, discarding\n");
			break;
		case NALU_TYPE_SEI:
			//printf ("read_new_slice: Found NALU_TYPE_SEI, len %d\n", nalu->len);
			InterpretSEIMessage(nalu->buf,nalu->len,img);
			break;
		case NALU_TYPE_PPS:
			ProcessPPS(nalu);
			break;
		case NALU_TYPE_SPS:
			ProcessSPS(nalu);
			break;
		case NALU_TYPE_AUD:
			//        printf ("read_new_slice: Found 'Access Unit Delimiter' NAL unit, len %d, ignored\n", nalu->len);
			break;
		case NALU_TYPE_EOSEQ:
			//        printf ("read_new_slice: Found 'End of Sequence' NAL unit, len %d, ignored\n", nalu->len);
			break;
		case NALU_TYPE_EOSTREAM:
			//        printf ("read_new_slice: Found 'End of Stream' NAL unit, len %d, ignored\n", nalu->len);
			break;
		case NALU_TYPE_FILL:
			printf ("read_new_slice: Found NALU_TYPE_FILL, len %d\n", (int) nalu->len);
			printf ("Skipping these filling bits, proceeding w/ next NALU\n");
			break;
		default:
			printf ("Found NALU type %d, len %d undefined, ignore NALU, moving on\n", (int) nalu->nal_unit_type, (int) nalu->len);
			break;
		}
	}
	FreeNALU(nalu);

	return  current_header;
}



/*!
************************************************************************
* \brief
*    finish decoding of a picture, conceal errors and store it
*    into the DPB
************************************************************************
*/
void exit_picture(StorablePicture **dec_picture)
{
	char yuv_types[4][6]= {"4:0:0","4:2:0","4:2:2","4:4:4"};
	int ercStartMB;
	int ercSegment;
	frame recfr;
	unsigned int i;
	int structure, frame_poc, slice_type, refpic, qp, pic_num, chroma_format_idc, is_idr;

	static char cslice_type[9];  

	int64 tmp_time;                   // time used by decoding the last frame
	char   yuvFormat[10];
	int nplane;

	// return if the last picture has already been finished
	if (*dec_picture==NULL)
	{
		return;
	}

	//deblocking for frame or field
	if( IS_INDEPENDENT(img) )
	{
		int colour_plane_id = img->colour_plane_id;
		for( nplane=0; nplane<MAX_PLANE; nplane++ )
		{
			change_plane_JV( nplane );
			DeblockPicture( img, *dec_picture );
		}
		img->colour_plane_id = colour_plane_id;
		make_frame_picture_JV();
	}
	else
	{
		DeblockPicture( img, *dec_picture );
	}

	if ((*dec_picture)->MbaffFrameFlag)
		MbAffPostProc();

	recfr.yptr = &(*dec_picture)->imgY[0][0];
	if ((*dec_picture)->chroma_format_idc != YUV400)
	{
		recfr.uptr = &(*dec_picture)->imgUV[0][0][0];
		recfr.vptr = &(*dec_picture)->imgUV[1][0][0];
	}

	//! this is always true at the beginning of a picture
	ercStartMB = 0;
	ercSegment = 0;

	//! mark the start of the first segment
	if (!(*dec_picture)->MbaffFrameFlag)
	{
		ercStartSegment(0, ercSegment, 0 , erc_errorVar);
		//! generate the segments according to the macroblock map
		for(i = 1; i<(*dec_picture)->PicSizeInMbs; i++)
		{
			if(img->mb_data[i].ei_flag != img->mb_data[i-1].ei_flag)
			{
				ercStopSegment(i-1, ercSegment, 0, erc_errorVar); //! stop current segment

				//! mark current segment as lost or OK
				if(img->mb_data[i-1].ei_flag)
					ercMarkCurrSegmentLost((*dec_picture)->size_x, erc_errorVar);
				else
					ercMarkCurrSegmentOK((*dec_picture)->size_x, erc_errorVar);

				ercSegment++;  //! next segment
				ercStartSegment(i, ercSegment, 0 , erc_errorVar); //! start new segment
				ercStartMB = i;//! save start MB for this segment
			}
		}
		//! mark end of the last segment
		ercStopSegment((*dec_picture)->PicSizeInMbs-1, ercSegment, 0, erc_errorVar);
		if(img->mb_data[i-1].ei_flag)
			ercMarkCurrSegmentLost((*dec_picture)->size_x, erc_errorVar);
		else
			ercMarkCurrSegmentOK((*dec_picture)->size_x, erc_errorVar);

		//! call the right error concealment function depending on the frame type.
		erc_mvperMB /= (*dec_picture)->PicSizeInMbs;

		erc_img = img;
		if((*dec_picture)->slice_type == I_SLICE || (*dec_picture)->slice_type == SI_SLICE) // I-frame
			ercConcealIntraFrame(&recfr, (*dec_picture)->size_x, (*dec_picture)->size_y, erc_errorVar);
		else
			ercConcealInterFrame(&recfr, erc_object_list, (*dec_picture)->size_x, (*dec_picture)->size_y, erc_errorVar, (*dec_picture)->chroma_format_idc);
	}

	if (img->structure == FRAME)         // buffer mgt. for frame mode
		frame_postprocessing(img);
	else
		field_postprocessing(img);   // reset all interlaced variables

	structure  = (*dec_picture)->structure;
	slice_type = (*dec_picture)->slice_type;
	frame_poc  = (*dec_picture)->frame_poc;
	refpic     = (*dec_picture)->used_for_reference;
	qp         = (*dec_picture)->qp;
	pic_num    = (*dec_picture)->pic_num;
	is_idr     = (*dec_picture)->idr_flag;

	chroma_format_idc = (*dec_picture)->chroma_format_idc;

	store_picture_in_dpb(*dec_picture);
	*dec_picture=NULL;

	if (img->last_has_mmco_5)
	{
		img->pre_frame_num = 0;
	}

	if (params->silent == FALSE)
	{
		if (structure==TOP_FIELD || structure==FRAME)
		{
			if(slice_type == I_SLICE && is_idr) // IDR picture
				strcpy(cslice_type,"IDR");
			else if(slice_type == I_SLICE) // I picture
				strcpy(cslice_type," I ");
			else if(slice_type == P_SLICE) // P pictures
				strcpy(cslice_type," P ");
			else if(slice_type == SP_SLICE) // SP pictures
				strcpy(cslice_type,"SP ");
			else if (slice_type == SI_SLICE)
				strcpy(cslice_type,"SI ");
			else if(refpic) // stored B pictures
				strcpy(cslice_type," B ");
			else // B pictures
				strcpy(cslice_type," b ");
			if (structure==FRAME)
			{
				strncat(cslice_type,")       ",8-strlen(cslice_type));
			}
		}
		else if (structure==BOTTOM_FIELD)
		{
			if(slice_type == I_SLICE && is_idr) // IDR picture
				strncat(cslice_type,"|IDR)",8-strlen(cslice_type));
			else if(slice_type == I_SLICE) // I picture
				strncat(cslice_type,"| I )",8-strlen(cslice_type));
			else if(slice_type == P_SLICE) // P pictures
				strncat(cslice_type,"| P )",8-strlen(cslice_type));
			else if(slice_type == SP_SLICE) // SP pictures
				strncat(cslice_type,"|SP )",8-strlen(cslice_type));
			else if (slice_type == SI_SLICE)
				strncat(cslice_type,"|SI )",8-strlen(cslice_type));
			else if(refpic) // stored B pictures
				strncat(cslice_type,"| B )",8-strlen(cslice_type));
			else // B pictures
				strncat(cslice_type,"| b )",8-strlen(cslice_type));   
		}
	}

	if ((structure==FRAME)||structure==BOTTOM_FIELD)
	{
		gettime (&(img->end_time));              // end time

		tmp_time  = timediff(&(img->start_time), &(img->end_time));
		tot_time += tmp_time;
		tmp_time  = timenorm(tmp_time);

		sprintf(yuvFormat,"%s", yuv_types[chroma_format_idc]);

		if (params->silent == FALSE)
		{
			if (p_ref != -1)
				fprintf(stdout,"%05d(%s%5d %5d %5d %8.4f %8.4f %8.4f  %s %7d\n",
				frame_no, cslice_type, frame_poc, pic_num, qp, snr->snr[0], snr->snr[1], snr->snr[2], yuvFormat, (int) tmp_time);
			else
				fprintf(stdout,"%05d(%s%5d %5d %5d                             %s %7d\n",
				frame_no, cslice_type, frame_poc, pic_num, qp, yuvFormat, (int)tmp_time);
		}
		else
			fprintf(stdout,"Completed Decoding frame %05d.\r",snr->frame_ctr);

		fflush(stdout);

		if(slice_type == I_SLICE || slice_type == SI_SLICE || slice_type == P_SLICE || refpic)   // I or P pictures
			img->number++;
		else
			Bframe_ctr++;    // B pictures
		snr->frame_ctr++;

		g_nFrame++;
	}

	img->current_mb_nr = -4712;   // impossible value for debugging, StW
	img->current_slice_nr = 0;
}

/*!
************************************************************************
* \brief
*    write the encoding mode and motion vectors of current
*    MB to the buffer of the error concealment module.
************************************************************************
*/

void ercWriteMBMODEandMV(Macroblock *currMB, ImageParameters *img,struct inp_par *inp)
{
	extern objectBuffer_t *erc_object_list;
	int i, ii, jj, currMBNum = img->current_mb_nr;
	int mbx = xPosMB(currMBNum,dec_picture->size_x), mby = yPosMB(currMBNum,dec_picture->size_x);
	objectBuffer_t *currRegion, *pRegion;
	short***  mv;

	currRegion = erc_object_list + (currMBNum<<2);

	if(img->type != B_SLICE) //non-B frame
	{
		for (i=0; i<4; i++)
		{
			pRegion             = currRegion + i;
			pRegion->regionMode = (currMB->mb_type  ==I16MB  ? REGMODE_INTRA      :
				currMB->b8mode[i]==IBLOCK ? REGMODE_INTRA_8x8  :
				currMB->b8mode[i]==0      ? REGMODE_INTER_COPY :
				currMB->b8mode[i]==1      ? REGMODE_INTER_PRED : REGMODE_INTER_PRED_8x8);
			if (currMB->b8mode[i]==0 || currMB->b8mode[i]==IBLOCK)  // INTRA OR COPY
			{
				pRegion->mv[0]    = 0;
				pRegion->mv[1]    = 0;
				pRegion->mv[2]    = 0;
			}
			else
			{
				ii              = 4*mbx + (i & 0x01)*2;// + BLOCK_SIZE;
				jj              = 4*mby + (i >> 1  )*2;
				if (currMB->b8mode[i]>=5 && currMB->b8mode[i]<=7)  // SMALL BLOCKS
				{
					pRegion->mv[0]  = (dec_picture->motion.mv[LIST_0][jj][ii][0] + dec_picture->motion.mv[LIST_0][jj][ii+1][0] + dec_picture->motion.mv[LIST_0][jj+1][ii][0] + dec_picture->motion.mv[LIST_0][jj+1][ii+1][0] + 2)/4;
					pRegion->mv[1]  = (dec_picture->motion.mv[LIST_0][jj][ii][1] + dec_picture->motion.mv[LIST_0][jj][ii+1][1] + dec_picture->motion.mv[LIST_0][jj+1][ii][1] + dec_picture->motion.mv[LIST_0][jj+1][ii+1][1] + 2)/4;
				}
				else // 16x16, 16x8, 8x16, 8x8
				{
					pRegion->mv[0]  = dec_picture->motion.mv[LIST_0][jj][ii][0];
					pRegion->mv[1]  = dec_picture->motion.mv[LIST_0][jj][ii][1];
					//          pRegion->mv[0]  = dec_picture->motion.mv[LIST_0][4*mby+(i/2)*2][4*mbx+(i%2)*2+BLOCK_SIZE][0];
					//          pRegion->mv[1]  = dec_picture->motion.mv[LIST_0][4*mby+(i/2)*2][4*mbx+(i%2)*2+BLOCK_SIZE][1];
				}
				erc_mvperMB      += iabs(pRegion->mv[0]) + iabs(pRegion->mv[1]);
				pRegion->mv[2]    = dec_picture->motion.ref_idx[LIST_0][jj][ii];
			}
		}
	}
	else  //B-frame
	{
		for (i=0; i<4; i++)
		{
			ii                  = 4*mbx + (i%2)*2;// + BLOCK_SIZE;
			jj                  = 4*mby + (i/2)*2;
			pRegion             = currRegion + i;
			pRegion->regionMode = (currMB->mb_type  ==I16MB  ? REGMODE_INTRA      :
				currMB->b8mode[i]==IBLOCK ? REGMODE_INTRA_8x8  : REGMODE_INTER_PRED_8x8);
			if (currMB->mb_type==I16MB || currMB->b8mode[i]==IBLOCK)  // INTRA
			{
				pRegion->mv[0]    = 0;
				pRegion->mv[1]    = 0;
				pRegion->mv[2]    = 0;
			}
			else
			{
				int idx = (dec_picture->motion.ref_idx[0][jj][ii]<0)?1:0;
				//        int idx = (currMB->b8mode[i]==0 && currMB->b8pdir[i]==2 ? LIST_0 : currMB->b8pdir[i]==1 ? LIST_1 : LIST_0);
				//        int idx = currMB->b8pdir[i]==0 ? LIST_0 : LIST_1;
				mv                = dec_picture->motion.mv[idx];
				pRegion->mv[0]    = (mv[jj][ii][0] + mv[jj][ii+1][0] + mv[jj+1][ii][0] + mv[jj+1][ii+1][0] + 2)/4;
				pRegion->mv[1]    = (mv[jj][ii][1] + mv[jj][ii+1][1] + mv[jj+1][ii][1] + mv[jj+1][ii+1][1] + 2)/4;
				erc_mvperMB      += iabs(pRegion->mv[0]) + iabs(pRegion->mv[1]);

				pRegion->mv[2]  = (dec_picture->motion.ref_idx[idx][jj][ii]);
				/*
				if (currMB->b8pdir[i]==0 || (currMB->b8pdir[i]==2 && currMB->b8mode[i]!=0)) // forward or bidirect
				{
				pRegion->mv[2]  = (dec_picture->motion.ref_idx[LIST_0][jj][ii]);
				///???? is it right, not only "img->fw_refFrArr[jj][ii-4]"
				}
				else
				{
				pRegion->mv[2]  = (dec_picture->motion.ref_idx[LIST_1][jj][ii]);
				//          pRegion->mv[2]  = 0;
				}
				*/
			}
		}
	}
}

/*!
************************************************************************
* \brief
*    set defaults for old_slice
*    NAL unit of a picture"
************************************************************************
*/
void init_old_slice(OldSliceParams *p_old_slice)
{
	p_old_slice->field_pic_flag = 0;

	p_old_slice->pps_id = INT_MAX;

	p_old_slice->frame_num = INT_MAX;

	p_old_slice->nal_ref_idc = INT_MAX;

	p_old_slice->idr_flag = FALSE;

	p_old_slice->pic_oder_cnt_lsb          = UINT_MAX;
	p_old_slice->delta_pic_oder_cnt_bottom = INT_MAX;

	p_old_slice->delta_pic_order_cnt[0] = INT_MAX;
	p_old_slice->delta_pic_order_cnt[1] = INT_MAX;
}

/*!
************************************************************************
* \brief
*    save slice parameters that are needed for checking of "first VCL
*    NAL unit of a picture"
************************************************************************
*/
void exit_slice(Slice *currSlice, OldSliceParams *p_old_slice)
{

	p_old_slice->pps_id = currSlice->pic_parameter_set_id;

	p_old_slice->frame_num = img->frame_num;

	p_old_slice->field_pic_flag = img->field_pic_flag;

	if(img->field_pic_flag)
	{
		p_old_slice->bottom_field_flag = img->bottom_field_flag;
	}

	p_old_slice->nal_ref_idc   = img->nal_reference_idc;

	p_old_slice->idr_flag = img->idr_flag;
	if (img->idr_flag)
	{
		p_old_slice->idr_pic_id = img->idr_pic_id;
	}

	if (active_sps->pic_order_cnt_type == 0)
	{
		p_old_slice->pic_oder_cnt_lsb          = img->pic_order_cnt_lsb;
		p_old_slice->delta_pic_oder_cnt_bottom = img->delta_pic_order_cnt_bottom;
	}

	if (active_sps->pic_order_cnt_type == 1)
	{
		p_old_slice->delta_pic_order_cnt[0] = img->delta_pic_order_cnt[0];
		p_old_slice->delta_pic_order_cnt[1] = img->delta_pic_order_cnt[1];
	}
}

/*!
************************************************************************
* \brief
*    detect if current slice is "first VCL NAL unit of a picture"
************************************************************************
*/
int is_new_picture(StorablePicture *dec_picture, Slice *currSlice, OldSliceParams *p_old_slice)
{
	int result=0;

	result |= (NULL==dec_picture);

	result |= (p_old_slice->pps_id != currSlice->pic_parameter_set_id);

	result |= (p_old_slice->frame_num != img->frame_num);

	result |= (p_old_slice->field_pic_flag != img->field_pic_flag);

	if(img->field_pic_flag && p_old_slice->field_pic_flag)
	{
		result |= (p_old_slice->bottom_field_flag != img->bottom_field_flag);
	}

	result |= (p_old_slice->nal_ref_idc != img->nal_reference_idc) && ((p_old_slice->nal_ref_idc == 0) || (img->nal_reference_idc == 0));

	result |= ( p_old_slice->idr_flag != img->idr_flag);

	if (img->idr_flag && p_old_slice->idr_flag)
	{
		result |= (p_old_slice->idr_pic_id != img->idr_pic_id);
	}

	if (active_sps->pic_order_cnt_type == 0)
	{
		result |= (p_old_slice->pic_oder_cnt_lsb          != img->pic_order_cnt_lsb);
		result |= (p_old_slice->delta_pic_oder_cnt_bottom != img->delta_pic_order_cnt_bottom);
	}

	if (active_sps->pic_order_cnt_type == 1)
	{
		result |= (p_old_slice->delta_pic_order_cnt[0] != img->delta_pic_order_cnt[0]);
		result |= (p_old_slice->delta_pic_order_cnt[1] != img->delta_pic_order_cnt[1]);
	}

	return result;
}



/*!
************************************************************************
* \brief
*    Prepare field and frame buffer after frame decoding
************************************************************************
*/
void frame_postprocessing(ImageParameters *img)
{
}

/*!
************************************************************************
* \brief
*    Prepare field and frame buffer after field decoding
************************************************************************
*/
void field_postprocessing(ImageParameters *img)
{
	img->number /= 2;
}



/*!
************************************************************************
* \brief
*    copy StorablePicture *src -> StorablePicture *dst
*    for 4:4:4 Independent mode
************************************************************************
*/
void copy_dec_picture_JV( StorablePicture *dst, StorablePicture *src )
{
	dst->top_poc              = src->top_poc;
	dst->bottom_poc           = src->bottom_poc;
	dst->frame_poc            = src->frame_poc;
	dst->qp                   = src->qp;
	dst->slice_qp_delta       = src->slice_qp_delta;
	dst->chroma_qp_offset[0]  = src->chroma_qp_offset[0];
	dst->chroma_qp_offset[1]  = src->chroma_qp_offset[1];

	dst->poc                  = src->poc;

	dst->slice_type           = src->slice_type;
	dst->used_for_reference   = src->used_for_reference;
	dst->idr_flag             = src->idr_flag;
	dst->no_output_of_prior_pics_flag = src->no_output_of_prior_pics_flag;
	dst->long_term_reference_flag = src->long_term_reference_flag;
	dst->adaptive_ref_pic_buffering_flag = src->adaptive_ref_pic_buffering_flag;

	dst->dec_ref_pic_marking_buffer = src->dec_ref_pic_marking_buffer;

	dst->MbaffFrameFlag       = src->MbaffFrameFlag;
	dst->PicWidthInMbs        = src->PicWidthInMbs;
	dst->pic_num              = src->pic_num;
	dst->frame_num            = src->frame_num;
	dst->recovery_frame       = src->recovery_frame;
	dst->coded_frame          = src->coded_frame;

	dst->chroma_format_idc    = src->chroma_format_idc;

	dst->frame_mbs_only_flag  = src->frame_mbs_only_flag;
	dst->frame_cropping_flag  = src->frame_cropping_flag;

	dst->frame_cropping_rect_left_offset   = src->frame_cropping_rect_left_offset;
	dst->frame_cropping_rect_right_offset  = src->frame_cropping_rect_right_offset;
	dst->frame_cropping_rect_top_offset    = src->frame_cropping_rect_top_offset;
	dst->frame_cropping_rect_bottom_offset = src->frame_cropping_rect_bottom_offset;

#if (ENABLE_OUTPUT_TONEMAPPING)
	// store the necessary tone mapping sei into StorablePicture structure
	dst->seiHasTone_mapping = src->seiHasTone_mapping;

	dst->seiHasTone_mapping    = src->seiHasTone_mapping;
	dst->tone_mapping_model_id = src->tone_mapping_model_id;
	dst->tonemapped_bit_depth  = src->tonemapped_bit_depth;
	if( src->tone_mapping_lut )
	{
		dst->tone_mapping_lut      = malloc(sizeof(int)*(1<<seiToneMapping.coded_data_bit_depth));
		if (NULL == dst->tone_mapping_lut)
		{
			no_mem_exit("copy_dec_picture_JV: tone_mapping_lut");
		}
		memcpy(dst->tone_mapping_lut, src->tone_mapping_lut, sizeof(imgpel)*(1<<seiToneMapping.coded_data_bit_depth));
	}
#endif
}


/*!
************************************************************************
* \brief
*    decodes one slice
************************************************************************
*/
void iconvert_mb(imgpel **CurImg, short islice)
{
	int j = 0, i = 0;
	int jpix, ipix;
	imgpel TemImg[16][32];
	jpix = img->pix_y;
	ipix = img->pix_x-16;

	if(islice == 0||img->cmb_type == CMB0)return;

	if(img->cmb_type == CMB1){
		for(j=0; j<16; j++)
			for(i=0; i<16; i++)
				TemImg[j][2*i + 1] = CurImg[jpix + j][ipix + i];

		for(j=0; j<16; j++)
			for(i=16; i<32; i++)
				TemImg[j][2*i - 32] = CurImg[jpix + j][ipix + i];

		for(j=0; j<16; j++)
			memcpy(&CurImg[jpix + j][ipix], &TemImg[j][0], 32 * sizeof(imgpel));	
	}
}

void getSubImageInteger_cmb(int mb_p_y, int mb_p_x, imgpel **dstMB, imgpel **CurImg)
{
	int i, j;  
	static imgpel *wBufSrc, *wBufDst; 

	for(j=0; j<16; j++)
	{
		wBufSrc = &CurImg[mb_p_y+j][mb_p_x-16];
		wBufDst = &dstMB[j+3][3];
		memcpy(wBufDst, wBufSrc, 16 * sizeof(imgpel));
		
		dstMB[j+3][19]=
		dstMB[j+3][20]=
		dstMB[j+3][21]= dstMB[j+3][18];

		if(mb_p_x == 16)
		{
			dstMB[j+3][0] = 
			dstMB[j+3][1] =
			dstMB[j+3][2] = dstMB[j+3][3];  
		}
		else
		{
			dstMB[j+3][0] = CurImg[mb_p_y+j][mb_p_x-21];
			dstMB[j+3][1] = CurImg[mb_p_y+j][mb_p_x-19];
			dstMB[j+3][2] = CurImg[mb_p_y+j][mb_p_x-17];
		}
	}
	
	if(mb_p_y == 0)
	{
		wBufSrc = dstMB[3];
		wBufDst = dstMB[2];
		memcpy(wBufDst, wBufSrc, 22 * sizeof(imgpel));
		wBufDst = dstMB[1];
		memcpy(wBufDst, wBufSrc, 22 * sizeof(imgpel));
		wBufDst = dstMB[0];
		memcpy(wBufDst, wBufSrc, 22 * sizeof(imgpel));
	}
	else
	{
		wBufSrc = &CurImg[mb_p_y-1][mb_p_x-16];
		wBufDst = &dstMB[2][2];
		memcpy(wBufDst, wBufSrc, 16 * sizeof(imgpel));

		wBufSrc = &CurImg[mb_p_y-2][mb_p_x-16];
		wBufDst = &dstMB[1][2];
		memcpy(wBufDst, wBufSrc, 16 * sizeof(imgpel));

		wBufSrc = &CurImg[mb_p_y-3][mb_p_x-16];
		wBufDst = &dstMB[0][2];
		memcpy(wBufDst, wBufSrc, 16 * sizeof(imgpel));

		if(mb_p_x == 16)
		{
			dstMB[0][0]=dstMB[0][1]=dstMB[0][2]=dstMB[0][2];
			dstMB[1][0]=dstMB[1][1]=dstMB[1][2]=dstMB[1][2];
			dstMB[2][0]=dstMB[2][1]=dstMB[2][2]=dstMB[1][2];			
		}
		else
		{
			dstMB[0][0]=CurImg[mb_p_y-3][mb_p_x-21];
			dstMB[0][1]=CurImg[mb_p_y-3][mb_p_x-19];
			dstMB[0][2]=CurImg[mb_p_y-3][mb_p_x-17];	

			dstMB[1][0]=CurImg[mb_p_y-2][mb_p_x-21];
			dstMB[1][1]=CurImg[mb_p_y-2][mb_p_x-19];
			dstMB[1][2]=CurImg[mb_p_y-2][mb_p_x-17];	

			dstMB[2][0]=CurImg[mb_p_y-1][mb_p_x-21];
			dstMB[2][1]=CurImg[mb_p_y-1][mb_p_x-19];
			dstMB[2][2]=CurImg[mb_p_y-1][mb_p_x-17];	
		}

		dstMB[0][21]=dstMB[0][20]=dstMB[0][19]=dstMB[0][18];
		dstMB[1][21]=dstMB[1][20]=dstMB[1][19]=dstMB[1][18];
		dstMB[2][21]=dstMB[2][20]=dstMB[2][19]=dstMB[2][18];
	}	

	wBufSrc = dstMB[18];
	wBufDst = dstMB[19];
	memcpy(wBufDst, wBufSrc, 20 * sizeof(imgpel));
	wBufDst = dstMB[20];
	memcpy(wBufDst, wBufSrc, 20 * sizeof(imgpel));
	wBufDst = dstMB[21];
	memcpy(wBufDst, wBufSrc, 20 * sizeof(imgpel));
	
}

void getHorSubImageSixTap_cmb( int eblock, imgpel **dstImg, imgpel **srcImg)//eblock=20
{
	int is, jpad, ipad;
	int ypadded_size = eblock;
	int xpadded_size = eblock;

	static imgpel *wBufSrc, *wBufDst;
	static imgpel *srcImgA, *srcImgB, *srcImgC, *srcImgD, *srcImgE, *srcImgF;
	static int *iBufDst;
	const int tap0 = ONE_FOURTH_TAP[0][0];
	const int tap1 = ONE_FOURTH_TAP[0][1];
	const int tap2 = ONE_FOURTH_TAP[0][2];

	for (jpad = 0; jpad < ypadded_size; jpad++)
	{
		wBufSrc = srcImg[jpad];     // 4:4:4 independent mode
		wBufDst = dstImg[jpad];     // 4:4:4 independent mode
		iBufDst = imgY_sub_cmb[jpad];

		srcImgA = &wBufSrc[0];
		srcImgB = &wBufSrc[0];      
		srcImgC = &wBufSrc[0];
		srcImgD = &wBufSrc[1];
		srcImgE = &wBufSrc[2];
		srcImgF = &wBufSrc[3];

		// left padded area
		is =
			(tap0 * (*srcImgA++ + *srcImgD++) +
			tap1 *  (*srcImgB   + *srcImgE++) +
			tap2 *  (*srcImgC   + *srcImgF++));

		*iBufDst++ =  is;
		*wBufDst++ = (imgpel) iClip1 ( 255, rshift_rnd_sf( is, 5 ) );      

		is =
			(tap0 * (*srcImgA++ + *srcImgD++) +
			tap1 *  (*srcImgB++ + *srcImgE++) +
			tap2 *  (*srcImgC   + *srcImgF++));

		*iBufDst++ =  is;
		*wBufDst++ = (imgpel) iClip1 ( 255, rshift_rnd_sf( is, 5 ) );      

		// center
		for (ipad = 2; ipad < xpadded_size - 4; ipad++)
		{
			is =
				(tap0 * (*srcImgA++ + *srcImgD++) +
				tap1 *  (*srcImgB++ + *srcImgE++) +
				tap2 *  (*srcImgC++ + *srcImgF++));

			*iBufDst++ =  is;
			*wBufDst++ = (imgpel) iClip1 ( 255, rshift_rnd_sf( is, 5 ) );      
		}

		is = (
			tap0 * (*srcImgA++ + *srcImgD++) +
			tap1 * (*srcImgB++ + *srcImgE++) +
			tap2 * (*srcImgC++ + *srcImgF  ));

		*iBufDst++ =  is;
		*wBufDst++ = (imgpel) iClip1 ( 255, rshift_rnd_sf( is, 5 ) );      

		// right padded area
		is = (
			tap0 * (*srcImgA++ + *srcImgD++) +
			tap1 * (*srcImgB++ + *srcImgE) +
			tap2 * (*srcImgC++ + *srcImgF));

		*iBufDst++ =  is;
		*wBufDst++ = (imgpel) iClip1 ( 255, rshift_rnd_sf( is, 5 ) );      

		is = (
			tap0 * (*srcImgA++ + *srcImgD) +
			tap1 * (*srcImgB++ + *srcImgE) +
			tap2 * (*srcImgC++ + *srcImgF));

		*iBufDst++ =  is;
		*wBufDst++ = (imgpel) iClip1 ( 255, rshift_rnd_sf( is, 5 ) );      

		is = (
			tap0 * (*srcImgA + *srcImgD) +
			tap1 * (*srcImgB + *srcImgE) +
			tap2 * (*srcImgC + *srcImgF));

		*iBufDst =  is;
		*wBufDst = (imgpel) iClip1 ( 255, rshift_rnd_sf( is, 5 ) );      

	}
}

void decode_one_slice(ImageParameters *img, Slice *currSlice, struct inp_par *inp)
{
	Boolean end_of_slice = FALSE;
	Macroblock *currMB = NULL;
	int mb_flag = 0;
	int i=0;
	int j=0;
	img->cod_counter=-1;
	img->cmb_type = CMB0;

	set_interpret_mb_mode(img->type);

	if( IS_INDEPENDENT(img) )
	{
		change_plane_JV( img->colour_plane_id );
	}

	set_ref_pic_num();

	if (img->type == B_SLICE)
	{
		if( IS_INDEPENDENT(img) )
		{
			compute_colocated_JV(Co_located, listX);
		}
		else
		{
			compute_colocated(Co_located, listX);
		}
	}

	//reset_ec_flags();

	while (end_of_slice == FALSE) // loop over macroblocks
	{

#if TRACE
		fprintf(p_trace,"\n*********** POC: %i (I/P) MB: %i Slice: %i Type %d **********\n", img->ThisPOC, img->current_mb_nr, img->current_slice_nr, img->type);
#endif

		// Initializes the current macroblock
		start_macroblock(img, &currMB);
		currMB->cmb_type = img->cmb_type;
		// Get the syntax elements from the NAL
		read_one_macroblock(img, currSlice, currMB);

		if(IS_INTRA(currMB)&&currMB->cmb_type == CMB1)
		{
			getSubImageInteger_cmb(img->pix_y, img->pix_x, cImgSub_cmb[0][0], dec_picture->imgY);
			getHorSubImageSixTap_cmb(22, cImgSub_cmb[0][2], cImgSub_cmb[0][0]);
			//for(j=0; j<16; j++)
			//	for(i=0; i<16; i++)
			//		printf("%5d", cImgSub_cmb[0][2][3+j][2+i]);
			//printf("\n");
		}

		decode_one_macroblock(img, currMB, dec_picture);

		if(IS_INTRA(currMB)&&img->cmb_type == CMB1)
		{
			iconvert_mb(dec_picture->imgY, 1);	
			//for(j = 0; j < 16; j++)
			//	for(i = 0; i < 16; i++)
			//		printf("%5d", dec_picture->imgY[img->mb_y*16+j][img->mb_x*16-16+i]);
			//printf("\n");
			
		}

		if(img->MbaffFrameFlag && dec_picture->motion.mb_field[img->current_mb_nr])
		{
			img->num_ref_idx_l0_active >>= 1;
			img->num_ref_idx_l1_active >>= 1;
		}

		ercWriteMBMODEandMV(currMB, img,inp);

		end_of_slice=exit_macroblock(img,(!img->MbaffFrameFlag||img->current_mb_nr%2));
		mb_flag++;
		img->cmb_type = (img->cmb_type == CMB0) ? CMB1:CMB0;
	}

	exit_slice(currSlice, &old_slice);
	//reset_ec_flags();
}
